"""
工具1：简历解析工具
功能：解析PDF/Word简历，提取结构化信息
"""
import json
import logging
from typing import Optional
from langchain.tools import BaseTool
import pdfplumber
from docx import Document

logger = logging.getLogger(__name__)


class ParseResumeTool(BaseTool):
    """
    简历解析工具
    
    支持格式：PDF、Word
    提取信息：姓名、联系方式、技能、工作经验、教育背景
    """
    
    name: str = "parse_resume_tool"
    description: str = """
        解析简历文件（PDF或Word格式），提取结构化信息。
        
        使用场景：
        - 候选人上传简历后自动解析
        - HR需要快速查看简历关键信息
        
        输入参数（JSON字符串）：
        {
            "file_path": "简历文件路径（必填）",
            "file_type": "文件类型：pdf 或 docx（可选，自动识别）"
        }
        
        返回格式（JSON字符串）：
        {
            "success": true/false,
            "data": {
                "name": "姓名",
                "phone": "电话",
                "email": "邮箱",
                "skills": ["Python", "Django", ...],
                "experience": "工作年限",
                "education": "学历",
                "raw_text": "原始文本"
            },
            "message": "解析成功/失败原因"
        }
        """
    
    def _run(self, file_path: str, file_type: Optional[str] = None) -> str:
        """
        执行简历解析
        
        Args:
            file_path: 简历文件路径
            file_type: 文件类型（pdf/docx），可选
        
        Returns:
            JSON字符串格式的解析结果
        """
        try:
            # 1. 参数校验
            if not file_path:
                return self._error_response("file_path不能为空")
            
            # 2. 自动识别文件类型
            if not file_type:
                if file_path.endswith('.pdf'):
                    file_type = 'pdf'
                elif file_path.endswith('.docx'):
                    file_type = 'docx'
                else:
                    return self._error_response("不支持的文件格式，仅支持PDF和Word")
            
            # 3. 提取文本
            if file_type == 'pdf':
                raw_text = self._extract_pdf(file_path)
            elif file_type == 'docx':
                raw_text = self._extract_docx(file_path)
            else:
                return self._error_response(f"不支持的文件类型: {file_type}")
            
            if not raw_text:
                return self._error_response("无法提取文本内容")
            
            # 4. 解析结构化信息
            parsed_data = self._parse_resume_text(raw_text)
            parsed_data["raw_text"] = raw_text[:500]  # 截取前500字符
            
            logger.info(f"简历解析成功: {file_path}")
            return self._success_response(parsed_data, "简历解析成功")
            
        except FileNotFoundError:
            return self._error_response(f"文件不存在: {file_path}")
        except Exception as e:
            logger.error(f"简历解析失败: {str(e)}", exc_info=True)
            return self._error_response(f"解析失败: {str(e)}")
    
    def _extract_pdf(self, file_path: str) -> str:
        """从PDF提取文本"""
        texts = []
        with pdfplumber.open(file_path) as pdf:
            for page in pdf.pages:
                text = page.extract_text()
                if text:
                    texts.append(text)
        return "\n".join(texts)
    
    def _extract_docx(self, file_path: str) -> str:
        """从Word文档提取文本"""
        doc = Document(file_path)
        texts = [para.text for para in doc.paragraphs if para.text.strip()]
        return "\n".join(texts)
    
    def _parse_resume_text(self, text: str) -> dict:
        """
        解析简历文本，提取结构化信息
        
        简化版实现：使用正则表达式和关键词匹配
        完整版可以接入NLP模型或LLM
        """
        import re
        
        parsed = {
            "name": "",
            "phone": "",
            "email": "",
            "skills": [],
            "experience": "",
            "education": ""
        }
        
        # 提取电话
        phone_pattern = r'1[3-9]\d{9}'
        phone_match = re.search(phone_pattern, text)
        if phone_match:
            parsed["phone"] = phone_match.group()
        
        # 提取邮箱
        email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
        email_match = re.search(email_pattern, text)
        if email_match:
            parsed["email"] = email_match.group()
        
        # 提取技能（简化版：匹配常见技术栈）
        skill_keywords = [
            'Python', 'Java', 'JavaScript', 'C++', 'Go', 'Rust',
            'Django', 'Flask', 'FastAPI', 'Spring', 'React', 'Vue',
            'MySQL', 'PostgreSQL', 'MongoDB', 'Redis',
            'Docker', 'Kubernetes', 'AWS', 'Azure',
            'LangChain', 'TensorFlow', 'PyTorch'
        ]
        
        for skill in skill_keywords:
            if skill.lower() in text.lower():
                parsed["skills"].append(skill)
        
        # 提取工作年限
        exp_patterns = [
            r'(\d+)\s*年.*经验',
            r'(\d+)\s*years',
            r'工作.*(\d+)\s*年'
        ]
        for pattern in exp_patterns:
            match = re.search(pattern, text, re.IGNORECASE)
            if match:
                parsed["experience"] = f"{match.group(1)}年"
                break
        
        # 提取学历
        education_keywords = ['博士', '硕士', '研究生', '本科', '大专', 'PhD', 'Master', 'Bachelor']
        for edu in education_keywords:
            if edu in text:
                parsed["education"] = edu
                break
        
        # 提取姓名（简化版：取第一行或包含"姓名"的行）
        lines = text.split('\n')
        for line in lines[:5]:  # 只看前5行
            if '姓名' in line:
                parsed["name"] = line.split('：')[-1].strip()
                break
        
        if not parsed["name"] and lines:
            # 假设第一行是姓名
            first_line = lines[0].strip()
            if len(first_line) <= 10 and not any(char.isdigit() for char in first_line):
                parsed["name"] = first_line
        
        return parsed
    
    def _success_response(self, data: dict, message: str) -> str:
        """成功响应"""
        return json.dumps({
            "success": True,
            "data": data,
            "message": message
        }, ensure_ascii=False)
    
    def _error_response(self, error: str) -> str:
        """失败响应"""
        return json.dumps({
            "success": False,
            "error": error,
            "message": "操作失败"
        }, ensure_ascii=False)
    
    async def _arun(self, *args, **kwargs):
        """异步执行（暂不实现）"""
        raise NotImplementedError("暂不支持异步调用")


